package simulacao;

// AgenteBot

// Java AgentBot.
// Autor: Alexandre Heideker - alexandre.heideker@ufabc.edu.br
// UFABC Jun/2009
//

import swarm.space.Grid2d;
import swarm.gui.Raster;

/**
 AgenteBot

<p>
A Heatbug is an agent in a 2-dimensional world. A Heatbug has the following
behavior:

 <dir>
 Each Heatbug has its own ideal temperature, and a color that indicates the 
 Heatbug's ideal temperature (more green for cool-loving Heatbugs, more yellow 
 for warmth-loving Heatbugs).
 </dir>

 <dir>
 O AgenteBot é uma simulação de robôs em mapas desconhecidos utilizando
 algoritmos de busca para aprendizado.
 </dir>

 <dir>
 Agentes:
	- Obstáculo (Wall)
		posição X,Y

	- Robo:
		posiçao x,y
		Nome - nome do agente
		TempoDoTrabalho - registra o tempo necessário para encontrar o alvo
		GridMemoriaPessoal - registra a BC obtida pelo agente
		GridMemóriaPública - registra a BC obtida em trocas
		Target - Objetivo escolhido entre os disponíveis
		AdicionaElementoBC - método para processar a BC obtida em interações
		tipo:
			- Robo AMIGO
				Fornece BC - troca informações com outros robôs (passam sua base de conhecimento)
				Absorve BC - adiciona base de conhecimento obtida com robôs amigos

			- Robo Não Amigo
				Fornece Dirt BC - Fornece BC falsa a fim de confundir AMIGO
	- Objetivo
		posição x,y
		nome

Base de conhecimento:
	- Grid 2d com os elementos encontrados em cada contato.

Forma de carregar um mapa.....
Após o mapa ser carregado, os objetivos são e os agentes. Cada agente recebe aleatoriamente a missão
de encontrar um objeto.
A simulação tem inicio e para quando todos os agentes robô alcançaram seu objetivo.

 </dir>

*/
public class Wall
{
    // Coordenas X,Y do bot:
    public int x, y;
    // Tempo para encontrar o alvo:
    public int tipo=4;
    // Objetivo:
    public String nome="parede";

// The chance that I will move arbitrarily:
// My index into the ColorMap defined in HeatbugModelSwarm:
public byte colorIndex=(byte)4;
private Grid2d _world;

// The model I belong to:
private BotModelSwarm _model;

public Wall (Grid2d world, BotModelSwarm model,
  int BotIndex )
{
    _world = world;
    _model = model;

    if (_world == null)
        System.err.println ("O Bot não tem um mundo!");
} /// constructor

public Object drawSelfOn (Raster raster)
{
    raster.drawPointX$Y$Color (x, y, colorIndex);
    return this;
}

/**
This method defines what the Heatbug does whenever the Schedule triggers it. 

<p>
The method is synchronized, which means the compiler will not let it be 
multi-threaded, which means it cannot be parallelized. It is synchronized 
because to avoid collisions, the Heatbugs must decide one at a time which 
cell to move to. 

<p>
There may be other methods in this simulation that should be synchronized. 

*/
public synchronized void BotStep ()
{


}

/**
This method does not check to see whether the target cell is already occupied.
*/
public Object putAtX$Y (int inX, int inY)
{
    x = inX;
    y = inY;
    _world.putObject$atX$Y (this, x, y);
    return this;
}

/**
The Java compiler will invoke this method whenever we use a Heatbug where the
compiler is expecting a String. That gives us an easy way to print diagnostics;
for example, System.out.println ("I initialized Heatbug " + heatbug + ".");.
*/
public String toString ()
{
    return this.nome;
}

} 
